22.4 Die Schriftdarstellung
 
22.4.1 Allgemeines
Bis zur Einführung von Windows 3.1 wurden hauptsächlich Bitmap-Schriften verwendet. Diese waren in einer bestimmten Größe gespeichert und konnten nicht skaliert werden. Mit der Einführung von Windows 3.1 änderte sich das, denn dieses Betriebssystem bescherte uns die skalierbaren TrueType-Schriften. Mit dem Ende der 90er-Jahre wurde uns mit OpenType ein weiteres Schriftformat vorgestellt, das eine Kombination aus TrueType und dem in PostScript verwendeten Type-1 ist.
Für die Entwicklung von GDI+-Anwendungen spielen nur TrueType und OpenType eine Rolle, alle anderen Formate werden nicht unterstützt. Sollten Sie dennoch dem Konstruktor der Font-Klasse eine Schriftart angeben, die nicht diesen Formaten entspricht, wird der Konstruktor automatisch die Standardschrift Microsoft Sans Serif einstellen.
22.4.2 Die Klassen »Font« und »FontFamily«
Das Format einer Schrift wird durch mehrere Eigenschaften festgelegt: Schriftgröße und Schrifttyp sind die offensichtlichsten. Dazu gesellen sich weitere Darstellungseigenschaften wie fett, kursiv usw.
Ein Schrifttyp wird aus der Klasse Font erzeugt. Durch die Wahl des passenden Konstruktors können die bekannten Attribute des Objekts angegeben werden. Mehrere Konstruktoren stehen uns dafür zur Verfügung, von denen ich Ihnen drei vorstellen möchte:
| public Font(Font, FontStyle);
|
| public Font(string, float);
|
| public Font(string, float, FontStyle);
|
Mit
| Font font = new Font("Arial", 12);
|
können Sie ein neues Font-Objekt erzeugen, das vom Typ der Schriftart »Arial« ist und eine Schriftgröße von 12 Punkten aufweist. Wenn Sie möchten, können Sie darüber hinaus auch sofort den Stil festlegen, wenn er vom Standard abweicht.
22.4.3 Der Schriftstil mit »FontStyle«
Der Schriftstil beschreibt, ob eine Schrift fett, kursiv, unterstrichen oder durchgestrichen dargestellt wird. Die Stile eines gegebenen Font-Objekts sind schreibgeschützt. Das bedeutet, dass Sie, falls Sie den Stil ändern wollen, ein neues Font-Objekt bereitstellen müssen, das über das entsprechende Attribut verfügt. Geeignet ist dazu der Konstruktor, der die Referenz auf ein existierendes Font-Objekt erwartet sowie die Angabe des zu setzenden Stils, z.B.:
| Font font = new Font(this.Font, FontStyle.Bold);
|
Bei dem Schriftstil kann es sich nur um eine Änderung der Darstellung handeln, die in der Enumeration FontStyle beschrieben wird.
Tabelle 22.7 Die Enumeration »FontStyle«
| FontStyle-Mitglied
|
Beschreibung
|
| Bold
|
Fett formatierter Text
|
| Italic
|
Kursiv formatierter Text
|
| Regular
|
Normaler Text
|
| Strikeout
|
Durchgestrichener Text
|
| Underline
|
Unterstrichener Text
|
Soll eine Schrift beispielsweise fett und kursiv sein, müssen die entsprechenden Konstanten mit dem bitweisen ODER-Operator verknüpft werden. Die folgende Anweisung bewirkt eine Änderung der Eigenschaft Font der Form in der Weise, dass die Schrift auf jeden Fall fett und kursiv angezeigt wird:
| frm.Font = new Font(frm.Font, FontStyle.Bold | FontStyle.Italic);
|
22.4.4 Die grafische Ausgabe einer Zeichenfolge
Analog zu den Methoden zur grafischen Darstellung von Linien, Kurven und geometrischen Figuren stellt die Klasse Graphics mit DrawString auch eine vielfach überladene Methode bereit, um eine Zeichenfolge als grafische Ausgabe zu behandeln. Einige davon möchte ich Ihnen vorstellen.
| public void DrawString(string, Font, Brush, PointF);
|
| public void DrawString(string, Font, Brush, PointF, StringFormat);
|
| public void DrawString(string, Font, Brush, float, float);
|
| public void DrawString(string, Font, Brush, float, float, StringFormat);
|
Die ersten drei Parameter sind in allen Methoden gleich: Es wird zuerst die zu zeichnende Zeichenfolge angegeben, anschließend die Schriftart und dann noch ein Objekt vom Typ Brush, um dem grafischen Layout einen großen Spielraum zu eröffnen. Die Parameter vom Typ float bzw. PointF steuern die Ausgabe der Zeichenfolge an einer vorherbestimmten Position. Dabei geben die koordinatenbeschreibenden Argumente die horizontale und die vertikale Koordinate der oberen linken Ecke für die anzuzeigende Zeichenfolge an.
| Hinweis Die beiden Strukturen Point und PointF unterscheiden sich dahingehend, dass Point die Punktkoordinaten als int beschreibt und PoitnF als float.
|
Ihnen unbekannt ist lediglich noch der Typ StringFormat, der Informationen über das Schriftlayout enthält und diverse Spezialeffekte ermöglicht. In Abschnitt 22.4.6 werden Sie mehr darüber erfahren.
Im folgenden Beispiel wird eine Zeichenfolge in die linke obere Ecke des ersten Quadranten des Clientbereichs der Form mit der DrawString-Methode gezeichnet und dieselbe Zeichenfolge auch noch in die linke obere Ecke des vierten Quadranten. Zur sichtbaren Aufteilung des Fensters in die Quadranten sorgen eine vertikale und eine horizontale Linie.
Hier klicken, um das Bild zu vergrößern
Abbildung 22.26 Ausgabe einer Zeichenfolge mit »DrawString«
| // --------------------------------------------------------------
|
| // Beispiel: ...\Kapitel 22\DrawStringDemo1
|
| // --------------------------------------------------------------
|
| private void Form1_Paint(object sender, PaintEventArgs e) {
|
| string str = " Hallo Welt";
|
| Font font = new Font("Arial", 20);
|
| Graphics gr = e.Graphics;
|
| gr.DrawString(str, font, Brushes.Black, 0, 0);
|
| gr.DrawLine(new Pen(Brushes.Blue), 0,
|
| this.ClientSize.Height / 2, this.ClientSize.Width,
|
| this.ClientSize.Height / 2);
|
| gr.DrawLine(new Pen(Brushes.Blue), this.ClientSize.Width / 2,
|
| 0, this.ClientSize.Width / 2,
|
| this.ClientSize.Height);
|
| gr.DrawString(str, font, Brushes.Black,
|
| this.ClientSize.Width / 2,
|
| this.ClientSize.Height / 2);
|
| }
|
22.4.5 Die Abmessungen mit »MeasureString« ermitteln
Die Festlegung des Startpunkts einer Zeichenfolge ist eine Sache, eine andere ist, die Abmessungen einer Zeichenfolge im Voraus zu wissen. Wie wollen Sie beispielsweise ansonsten die Zeichenfolge »Hallo Welt« mittig im Clientbereich einer grafikfähigen Komponente zeichnen lassen? Sie müssen wissen, wie viel Platz die Zeichenfolge sowohl horizontal als auch vertikal für sich beansprucht.
Hier hilft uns die Methode MeasureString der Klasse Graphics. Diese Methode ist wieder vielfach überladen, liefert aber in allen Fällen die Referenz auf ein SizeF-Objekt zurück. Sehen wir uns nur die einfachste und vermutlich auch am häufigsten benutzte Variante an, die als Argumente die Zeichenfolge selbst sowie die gewünschte Schriftart benötigt.
| public SizeF MeasureString(string, Font);
|
Die Struktur SizeF stellt einen rechteckigen Bereich zur Verfügung, dessen Abmessungen durch die Eigenschaften Height und Width beschrieben werden, welche die Abmessungen als float zurückliefern.
Mit MeasureString können wir die Abmessungen einer Zeichenfolge erfahren. Damit sind wir aber noch nicht in der Lage, diese zentriert in einem Clientbereich zu positionieren, denn der Startpunkt des zeichenfolgenumschließenden Rechtecks liegt links oben und würde immer noch dazu führen, dass wir eine verhältnismäßig aufwändige Berechnung anstellen müssten, um die Zeichenfolge zentriert anzuzeigen. Es gibt eine bessere Lösung, die über die Klasse StringFormat führt.
22.4.6 Die Klasse »StringFormat«
Ein Objekt vom Typ StringFormat enthält Informationen für das Textlayout, beispielsweise die Textausrichtung und der Zeilenabstand.
Mit den beiden Eigenschaften Alignment und LineAlignment kann eine Zeichenfolge positioniert werden:
| public StringAlignment Alignment {get; set;}
|
| public StringAlignment LineAlignment {get; set;}
|
Alignment beschreibt die horizontale Ausrichtung eines Textes, LineAlignment die vertikale. Beide sind vom Typ StringAlignment, einer Enumeration, die drei Konstanten definiert.
Tabelle 22.8 Mitglieder der Enumeration »StringAlignment«
| StringAlignment-Member
|
Beschreibung
|
| Near
|
Die Ausrichtung orientiert sich an der linken oberen Ecke.
|
| Center
|
Die Ausrichtung ist zentriert in der Mitte.
|
| Far
|
Die Ausrichtung orientiert sich an der rechten unteren Ecke.
|
Damit wird die Lösung zur zentrierten Ausgabe einer Zeichenfolge sehr einfach: Wir erzeugen nur ein StringFormat-Objekt und legen die beiden Eigenschaften Alignment und LineAlignment auf StringAlignment.Center fest. Anschließend übergeben wir das StringFormat-Objekt der DrawString-Methode.
| // --------------------------------------------------------------
|
| // Beispiel: ...\Kapitel 22\DrawStringDemo2
|
| // --------------------------------------------------------------
|
| ...
|
| // Ausgabe einer zentrierten Zeichenfolge
|
| private void Form1_Paint(object sender, PaintEventArgs e) {
|
| string str = " Hallo Welt";
|
| Font font = new Font("Arial", 20);
|
| Graphics gr = e.Graphics;
|
| StringFormat strFormat = new StringFormat();
|
| strFormat.Alignment = StringAlignment.Center;
|
| strFormat.LineAlignment = StringAlignment.Center;
|
| gr.DrawLine(new Pen(Brushes.Blue), 0,
|
| this.ClientSize.Height / 2,
|
| this.ClientSize.Width,
|
| this.ClientSize.Height / 2);
|
| gr.DrawLine(new Pen(Brushes.Blue), this.ClientSize.Width / 2,
|
| 0, this.ClientSize.Width / 2,
|
| this.ClientSize.Height);
|
| gr.DrawString(str, font, Brushes.Black,
|
| this.ClientSize.Width / 2,
|
| this.ClientSize.Height / 2, strFormat);
|
| }
|
Hier klicken, um das Bild zu vergrößern
Abbildung 22.27 Ausgabe einer zentrierten Zeichenfolge |
